home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / m2c / Parser.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  44KB  |  1,357 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Scanner
  4. #include "Scanner.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Positions
  8. #include "Positions.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Errors
  12. #include "Errors.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Strings
  16. #include "Strings.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_DynArray
  20. #include "DynArray.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Sets
  24. #include "Sets.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_System
  28. #include "System.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Errors
  32. #include "Errors.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Tree0
  36. #include "Tree0.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Tree
  40. #include "Tree.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Sets
  44. #include "Sets.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Strings
  48. #include "Strings.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Lists
  52. #include "Lists.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_StringMem
  56. #include "StringMem.h"
  57. #endif
  58.  
  59. #ifndef DEFINITION_Idents
  60. #include "Idents.h"
  61. #endif
  62.  
  63. #ifndef DEFINITION_DefTable
  64. #include "DefTable.h"
  65. #endif
  66.  
  67. #ifndef DEFINITION_GenTabs
  68. #include "GenTabs.h"
  69. #endif
  70.  
  71. #ifndef DEFINITION_Dfa
  72. #include "Dfa.h"
  73. #endif
  74.  
  75. #ifndef DEFINITION_ScanGen
  76. #include "ScanGen.h"
  77. #endif
  78.  
  79. #ifndef DEFINITION_Parser
  80. #include "Parser.h"
  81. #endif
  82.  
  83. struct Parser_1 Parser_ParsTabName;
  84.  
  85. #define IdentUndefined    10
  86. #define ImproperUse    11
  87. #define IdentDefBefore    12
  88. #define Error    3
  89. #define C_1_String    7
  90. typedef struct S_1 {
  91.     union {
  92.         struct {
  93.             Scanner_tScanAttribute Scan;
  94.         } V_1;
  95.         struct {
  96.             Tree0_tTree0 Tree;
  97.         } V_2;
  98.         struct {
  99.             BOOLEAN IsLeftJust;
  100.             Positions_tPosition Position;
  101.         } V_3;
  102.         struct {
  103.             Sets_tSet Set;
  104.         } V_4;
  105.     } U_1;
  106. } tParsAttribute;
  107. static SHORTCARD Number;
  108. static CHAR ch;
  109. static BOOLEAN bool;
  110. static Strings_tString string;
  111. static StringMem_tStringRef stringref;
  112. static Lists_tList Text;
  113. static Sets_tSet set;
  114. static Tree0_tTree0 tree;
  115. static Tree_tTree tree1;
  116. static DefTable_DefRange Definition;
  117. static DefTable_tKind Kind;
  118. static Idents_tIdent Identifier;
  119. static Tree0_tTree0 nNode, EOLTree;
  120. static Tree0_tTree0 AppendRule ARGS((Tree0_tTree0 Tree, CHAR Ch, Lists_tList Text));
  121. #define yyInitStackSize    100
  122. #define yyNoState    0
  123. #define yyFirstTerminal    0
  124. #define yyLastTerminal    38
  125. #define yyFirstSymbol    0
  126. #define yyLastSymbol    64
  127. #define yyTableMax    221
  128. #define yyNTableMax    89
  129. #define yyFirstReadState    1
  130. #define yyLastReadState    55
  131. #define yyFirstReadTermState    56
  132. #define yyLastReadTermState    84
  133. #define yyLastReadNontermState    99
  134. #define yyFirstReduceState    100
  135. #define yyLastReduceState    164
  136. #define yyStartState    1
  137. #define yyStopState    100
  138. #define yyFirstFinalState    yyFirstReadTermState
  139. #define yyLastState    yyLastReduceState
  140. typedef SHORTCARD yyTableElmt;
  141. typedef yyTableElmt yyTCombRange;
  142. typedef yyTableElmt yyNCombRange;
  143. typedef yyTableElmt yyStateRange;
  144. typedef yyTableElmt yyReadRange;
  145. typedef yyTableElmt yyReadReduceRange;
  146. typedef yyTableElmt yyReduceRange;
  147. typedef yyTableElmt yySymbolRange;
  148. typedef struct S_2 {
  149.     yyStateRange Check, Next;
  150. } yyTCombType;
  151. typedef yyStateRange yyNCombType;
  152. typedef yyTCombType *yyTCombTypePtr;
  153. typedef yyNCombType *yyNCombTypePtr;
  154. typedef struct S_3 {
  155.     yyStateRange A[1000000 + 1];
  156. } *yyStackType;
  157. static struct S_4 {
  158.     yyTCombTypePtr A[yyLastReadState + 1];
  159. } yyTBasePtr;
  160. static struct S_5 {
  161.     yyNCombTypePtr A[yyLastReadState + 1];
  162. } yyNBasePtr;
  163. static struct S_6 {
  164.     yyReadRange A[yyLastReadState + 1];
  165. } yyDefault;
  166. static struct S_7 {
  167.     yyTCombType A[yyTableMax + 1];
  168. } yyTComb;
  169. static struct S_8 {
  170.     yyNCombType A[yyNTableMax - (yyLastTerminal + 1) + 1];
  171. } yyNComb;
  172. static struct S_9 {
  173.     yyTableElmt A[yyLastReduceState - yyFirstReduceState + 1];
  174. } yyLength;
  175. static struct S_10 {
  176.     yySymbolRange A[yyLastReduceState - yyFirstReduceState + 1];
  177. } yyLeftHandSide;
  178. static struct S_11 {
  179.     yySymbolRange A[yyLastReadState + 1];
  180. } yyContinuation;
  181. static struct S_12 {
  182.     yyReduceRange A[yyLastReadNontermState - yyFirstReadTermState + 1];
  183. } yyFinalToProd;
  184. static BOOLEAN yyIsInitialized;
  185. static System_tFile yyTableFile;
  186. static void Copy ARGS((CHAR Source[], LONGCARD , CHAR Target[], LONGCARD ));
  187. struct S_16 {
  188.     tParsAttribute A[1000000 + 1];
  189. };
  190. struct S_17 {
  191.     CHAR A[127 + 1];
  192. };
  193. static void ErrorRecovery ARGS((yySymbolRange *Terminal, yyStackType StateStack, LONGINT StackSize, LONGINT StackPtr));
  194. struct S_18 {
  195.     CHAR A[127 + 1];
  196. };
  197. static void ComputeContinuation ARGS((yyStackType Stack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *ContinueSet));
  198. static BOOLEAN IsContinuation ARGS((yySymbolRange Terminal, yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr));
  199. static void ComputeRestartPoints ARGS((yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *RestartSet));
  200. static yyStateRange Next ARGS((yyStateRange State, yySymbolRange Symbol));
  201. static void yyGetTables ARGS(());
  202. struct S_19 {
  203.     yyTCombRange A[yyLastReadState + 1];
  204. };
  205. struct S_20 {
  206.     yyNCombRange A[yyLastReadState + 1];
  207. };
  208. static CARDINAL yyGetTable ARGS((ADDRESS Address));
  209. static void yyErrorCheck ARGS((INTEGER ErrorCode, INTEGER Info));
  210. static void BeginParser ARGS(());
  211.  
  212.  
  213. static Tree0_tTree0 AppendRule
  214. # ifdef __STDC__
  215. (Tree0_tTree0 Tree, CHAR Ch, Lists_tList Text)
  216. # else
  217. (Tree, Ch, Text)
  218. Tree0_tTree0 Tree;
  219. CHAR Ch;
  220. Lists_tList Text;
  221. # endif
  222. {
  223.   Sets_tSet Set;
  224.   Tree0_tTree0 t;
  225.  
  226.   Sets_MakeSet(&Set, (LONGCARD)GenTabs_StartStateCount);
  227.   Sets_Complement(&Set);
  228.   Sets_Exclude(&Set, 0L);
  229.   t = Tree0_mCh(Ch);
  230.   INC(GenTabs_PatternCount);
  231.   t = Tree0_mPattern(Set, t, nNode, GenTabs_PatternCount, Positions_NoPosition);
  232.   t = Tree0_mList(nNode, t);
  233.   INC(GenTabs_RuleCount);
  234.   t = Tree0_mRule(t, Text, 0, ScanGen_NoPosition, GenTabs_RuleCount);
  235.   return Tree0_mList(Tree, t);
  236. }
  237.  
  238. static void Copy
  239. # ifdef __STDC__
  240. (CHAR Source[], LONGCARD O_2, CHAR Target[], LONGCARD O_1)
  241. # else
  242. (Source, O_2, Target, O_1)
  243. CHAR Source[];
  244. LONGCARD O_2;
  245. CHAR Target[];
  246. LONGCARD O_1;
  247. # endif
  248. {
  249.   CARDINAL i, j;
  250.   OPEN_ARRAY_LOCALS
  251.  
  252.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(CHAR), 1)
  253.   COPY_OPEN_ARRAY(Source, O_2, CHAR)
  254.   if ((O_2 - 1) < (O_1 - 1)) {
  255.     j = (O_2 - 1);
  256.   } else {
  257.     j = (O_1 - 1);
  258.   }
  259.   {
  260.     LONGCARD B_1 = 0, B_2 = j;
  261.  
  262.     if (B_1 <= B_2)
  263.       for (i = B_1;; i += 1) {
  264.         Target[i] = Source[i];
  265.         if (i >= B_2) break;
  266.       }
  267.   }
  268.   if ((O_1 - 1) > j) {
  269.     Target[j + 1] = CHR(0);
  270.   }
  271.   FREE_OPEN_ARRAYS
  272. }
  273.  
  274. void Parser_TokenName
  275. # ifdef __STDC__
  276. (CARDINAL Token, CHAR Name[], LONGCARD O_3)
  277. # else
  278. (Token, Name, O_3)
  279. CARDINAL Token;
  280. CHAR Name[];
  281. LONGCARD O_3;
  282. # endif
  283. {
  284.   switch (Token) {
  285.   case 0:;
  286.     Copy((STRING)"_EndOfFile", 10L, Name, O_3);
  287.     break;
  288.   case 1:;
  289.     Copy((STRING)"Ident", 5L, Name, O_3);
  290.     break;
  291.   case 2:;
  292.     Copy((STRING)"Number", 6L, Name, O_3);
  293.     break;
  294.   case 3:;
  295.     Copy((STRING)"String", 6L, Name, O_3);
  296.     break;
  297.   case 4:;
  298.     Copy((STRING)"Char", 4L, Name, O_3);
  299.     break;
  300.   case 5:;
  301.     Copy((STRING)"TargetCode", 10L, Name, O_3);
  302.     break;
  303.   case 6:;
  304.     Copy((STRING)"GLOBAL", 6L, Name, O_3);
  305.     break;
  306.   case 7:;
  307.     Copy((STRING)"BEGIN", 5L, Name, O_3);
  308.     break;
  309.   case 8:;
  310.     Copy((STRING)"CLOSE", 5L, Name, O_3);
  311.     break;
  312.   case 9:;
  313.     Copy((STRING)"DEFINE", 6L, Name, O_3);
  314.     break;
  315.   case 10:;
  316.     Copy((STRING)"START", 5L, Name, O_3);
  317.     break;
  318.   case 11:;
  319.     Copy((STRING)"RULES", 5L, Name, O_3);
  320.     break;
  321.   case 12:;
  322.     Copy((STRING)".", 1L, Name, O_3);
  323.     break;
  324.   case 13:;
  325.     Copy((STRING)",", 1L, Name, O_3);
  326.     break;
  327.   case 14:;
  328.     Copy((STRING)"=", 1L, Name, O_3);
  329.     break;
  330.   case 15:;
  331.     Copy((STRING)":", 1L, Name, O_3);
  332.     break;
  333.   case 16:;
  334.     Copy((STRING)"/", 1L, Name, O_3);
  335.     break;
  336.   case 17:;
  337.     Copy((STRING)"|", 1L, Name, O_3);
  338.     break;
  339.   case 18:;
  340.     Copy((STRING)"+", 1L, Name, O_3);
  341.     break;
  342.   case 19:;
  343.     Copy((STRING)"-", 1L, Name, O_3);
  344.     break;
  345.   case 20:;
  346.     Copy((STRING)"*", 1L, Name, O_3);
  347.     break;
  348.   case 21:;
  349.     Copy((STRING)"?", 1L, Name, O_3);
  350.     break;
  351.   case 22:;
  352.     Copy((STRING)"(", 1L, Name, O_3);
  353.     break;
  354.   case 23:;
  355.     Copy((STRING)")", 1L, Name, O_3);
  356.     break;
  357.   case 24:;
  358.     Copy((STRING)"[", 1L, Name, O_3);
  359.     break;
  360.   case 25:;
  361.     Copy((STRING)"]", 1L, Name, O_3);
  362.     break;
  363.   case 26:;
  364.     Copy((STRING)"{", 1L, Name, O_3);
  365.     break;
  366.   case 27:;
  367.     Copy((STRING)"}", 1L, Name, O_3);
  368.     break;
  369.   case 28:;
  370.     Copy((STRING)"<", 1L, Name, O_3);
  371.     break;
  372.   case 29:;
  373.     Copy((STRING)">", 1L, Name, O_3);
  374.     break;
  375.   case 30:;
  376.     Copy((STRING)"NOT", 3L, Name, O_3);
  377.     break;
  378.   case 31:;
  379.     Copy((STRING)"LOCAL", 5L, Name, O_3);
  380.     break;
  381.   case 32:;
  382.     Copy((STRING)"EXPORT", 6L, Name, O_3);
  383.     break;
  384.   case 33:;
  385.     Copy((STRING)"#", 1L, Name, O_3);
  386.     break;
  387.   case 34:;
  388.     Copy((STRING)"EOF", 3L, Name, O_3);
  389.     break;
  390.   case 35:;
  391.     Copy((STRING)":-", 2L, Name, O_3);
  392.     break;
  393.   case 36:;
  394.     Copy((STRING)"DEFAULT", 7L, Name, O_3);
  395.     break;
  396.   case 37:;
  397.     Copy((STRING)"SCANNER", 7L, Name, O_3);
  398.     break;
  399.   case 38:;
  400.     Copy((STRING)"SEQUENCE", 8L, Name, O_3);
  401.     break;
  402.   }
  403. }
  404.  
  405. CARDINAL Parser_Parser
  406. # ifdef __STDC__
  407. ()
  408. # else
  409. ()
  410. # endif
  411. {
  412.   yyStateRange yyState;
  413.   yySymbolRange yyTerminal;
  414.   yySymbolRange yyNonterminal;
  415.   yyTableElmt yyStackPtr;
  416.   LONGINT yyStateStackSize;
  417.   LONGINT yyAttrStackSize;
  418.   yyTableElmt yyShortStackSize;
  419.   yyStackType yyStateStack;
  420.   struct S_16 *yyAttributeStack;
  421.   tParsAttribute yySynAttribute;
  422.   Scanner_tScanAttribute yyRepairAttribute;
  423.   yySymbolRange yyRepairToken;
  424.   yyTCombTypePtr yyTCombPtr;
  425.   yyNCombTypePtr yyNCombPtr;
  426.   BOOLEAN yyIsRepairing;
  427.   CARDINAL yyErrorCount;
  428.   struct S_17 yyTokenString;
  429.  
  430.   BeginParser();
  431.   yyState = yyStartState;
  432.   yyTerminal = Scanner_GetToken();
  433.   yyStateStackSize = yyInitStackSize;
  434.   yyAttrStackSize = yyInitStackSize;
  435.   DynArray_MakeArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  436.   DynArray_MakeArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  437.   yyShortStackSize = yyStateStackSize - 1;
  438.   yyStackPtr = 0;
  439.   yyErrorCount = 0;
  440.   yyIsRepairing = FALSE;
  441.   for (;;) {
  442.     if (yyStackPtr >= yyShortStackSize) {
  443.       DynArray_ExtendArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyStateRange));
  444.       DynArray_ExtendArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  445.       yyShortStackSize = yyStateStackSize - 1;
  446.     }
  447.     yyStateStack->A[yyStackPtr] = yyState;
  448.     for (;;) {
  449.       yyTCombPtr = (yyTCombTypePtr)((LONGCARD)yyTBasePtr.A[yyState] + yyTerminal * sizeof(yyTCombType));
  450.       if (yyTCombPtr->Check == yyState) {
  451.         yyState = yyTCombPtr->Next;
  452.         goto EXIT_2;
  453.       }
  454.       yyState = yyDefault.A[yyState];
  455.       if (yyState == yyNoState) {
  456.         yyState = yyStateStack->A[yyStackPtr];
  457.         if (yyIsRepairing) {
  458.           yyRepairToken = yyContinuation.A[yyState];
  459.           yyState = Next(yyState, yyRepairToken);
  460.           if (yyState <= yyLastReadTermState) {
  461.             Scanner_ErrorAttribute((LONGCARD)yyRepairToken, &yyRepairAttribute);
  462.             Parser_TokenName((LONGCARD)yyRepairToken, yyTokenString.A, 128L);
  463.             Errors_ErrorMessageI((LONGCARD)Errors_TokenInserted, (LONGCARD)Errors_Repair, Scanner_Attribute.Position, (LONGCARD)Errors_Array, ADR(yyTokenString));
  464.             if (yyState >= yyFirstFinalState) {
  465.               yyState = yyFinalToProd.A[yyState - 56];
  466.             }
  467.             INC(yyStackPtr);
  468.             yyAttributeStack->A[yyStackPtr].U_1.V_1.Scan = yyRepairAttribute;
  469.             yyStateStack->A[yyStackPtr] = yyState;
  470.           }
  471.           if (yyState >= yyFirstFinalState) {
  472.             goto EXIT_2;
  473.           }
  474.         } else {
  475.           INC(yyErrorCount);
  476.           ErrorRecovery(&yyTerminal, yyStateStack, yyStateStackSize, (LONGINT)yyStackPtr);
  477.           yyIsRepairing = TRUE;
  478.         }
  479.       }
  480.     } EXIT_2:;
  481.     if (yyState >= yyFirstFinalState) {
  482.       if (yyState <= yyLastReadTermState) {
  483.         INC(yyStackPtr);
  484.         yyAttributeStack->A[yyStackPtr].U_1.V_1.Scan = Scanner_Attribute;
  485.         yyTerminal = Scanner_GetToken();
  486.         yyIsRepairing = FALSE;
  487.       }
  488.       for (;;) {
  489.         switch (yyState) {
  490.         case 100:;
  491.           DynArray_ReleaseArray((ADDRESS *)&yyStateStack, &yyStateStackSize, (LONGINT)sizeof(yyTableElmt));
  492.           DynArray_ReleaseArray((ADDRESS *)&yyAttributeStack, &yyAttrStackSize, (LONGINT)sizeof(tParsAttribute));
  493.           return yyErrorCount;
  494.           break;
  495.         case 101:;
  496.         case 99:;
  497.           DEC1(yyStackPtr, 6);
  498.           yyNonterminal = 45;
  499.           break;
  500.         case 102:;
  501.           DEC1(yyStackPtr, 0);
  502.           yyNonterminal = 39;
  503.           GenTabs_StartStateCount = 0;
  504.           GenTabs_RuleCount = 0;
  505.           GenTabs_PatternCount = 0;
  506.           GenTabs_LeftJustUsed = FALSE;
  507.           EOLTree = Tree0_mCh(Dfa_EolCh);
  508.           Strings_ArrayToString((STRING)"ANY", 3L, &string);
  509.           Sets_MakeSet(&set, ORD(Dfa_LastCh));
  510.           Sets_Complement(&set);
  511.           Sets_Exclude(&set, ORD(Dfa_EolCh));
  512.           DefTable_MakeIdentDef(Idents_MakeIdent(&string), (Tree_tTree)(ADDRESS)Tree0_mSet(set), 1, FALSE);
  513.           Strings_ArrayToString((STRING)"STD", 3L, &string);
  514.           DefTable_MakeStartDef(Idents_MakeIdent(&string), (SHORTCARD)(GenTabs_StartStateCount + 1));
  515.           INC1(GenTabs_StartStateCount, 2);
  516.           break;
  517.         case 103:;
  518.           DEC1(yyStackPtr, 0);
  519.           yyNonterminal = 40;
  520.           ScanGen_ScannerName = Idents_NoIdent;
  521.           break;
  522.         case 104:;
  523.           DEC1(yyStackPtr, 1);
  524.           yyNonterminal = 40;
  525.           Strings_ArrayToString((STRING)"Scanner", 7L, &string);
  526.           ScanGen_ScannerName = Idents_MakeIdent(&string);
  527.           break;
  528.         case 105:;
  529.         case 56:;
  530.           DEC1(yyStackPtr, 2);
  531.           yyNonterminal = 40;
  532.           ScanGen_ScannerName = yyAttributeStack->A[yyStackPtr + 2].U_1.V_1.Scan.U_1.V_1.Ident;
  533.           break;
  534.         case 106:;
  535.           DEC1(yyStackPtr, 0);
  536.           yyNonterminal = 41;
  537.           break;
  538.         case 107:;
  539.         case 74:;
  540.           DEC1(yyStackPtr, 3);
  541.           yyNonterminal = 41;
  542.           ScanGen_Export = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text;
  543.           ScanGen_ExportLine = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line;
  544.           break;
  545.         case 108:;
  546.         case 57:;
  547.           DEC1(yyStackPtr, 3);
  548.           yyNonterminal = 41;
  549.           ScanGen_Global = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text;
  550.           ScanGen_GlobalLine = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line;
  551.           break;
  552.         case 109:;
  553.         case 73:;
  554.           DEC1(yyStackPtr, 3);
  555.           yyNonterminal = 41;
  556.           ScanGen_Local = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text;
  557.           ScanGen_LocalLine = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line;
  558.           break;
  559.         case 110:;
  560.         case 58:;
  561.           DEC1(yyStackPtr, 3);
  562.           yyNonterminal = 41;
  563.           ScanGen_Begin = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text;
  564.           ScanGen_BeginLine = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line;
  565.           break;
  566.         case 111:;
  567.         case 59:;
  568.           DEC1(yyStackPtr, 3);
  569.           yyNonterminal = 41;
  570.           ScanGen_Close = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text;
  571.           ScanGen_CloseLine = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line;
  572.           break;
  573.         case 112:;
  574.         case 76:;
  575.           DEC1(yyStackPtr, 3);
  576.           yyNonterminal = 41;
  577.           ScanGen_Default = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text;
  578.           ScanGen_DefaultLine = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line;
  579.           break;
  580.         case 113:;
  581.         case 75:;
  582.           DEC1(yyStackPtr, 3);
  583.           yyNonterminal = 41;
  584.           ScanGen_Eof = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text;
  585.           ScanGen_EofLine = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line;
  586.           break;
  587.         case 114:;
  588.           DEC1(yyStackPtr, 0);
  589.           yyNonterminal = 42;
  590.           ScanGen_InitScanGen();
  591.           break;
  592.         case 115:;
  593.           DEC1(yyStackPtr, 2);
  594.           yyNonterminal = 42;
  595.           ScanGen_InitScanGen();
  596.           break;
  597.         case 116:;
  598.           DEC1(yyStackPtr, 0);
  599.           yyNonterminal = 43;
  600.           break;
  601.         case 117:;
  602.           DEC1(yyStackPtr, 2);
  603.           yyNonterminal = 43;
  604.           break;
  605.         case 118:;
  606.           DEC1(yyStackPtr, 2);
  607.           yyNonterminal = 44;
  608.           Tree0_Tree0Root = yyAttributeStack->A[yyStackPtr + 2].U_1.V_2.Tree;
  609.           Tree0_Tree0Root = AppendRule(Tree0_Tree0Root, Dfa_BlankCh, ScanGen_BlankText);
  610.           Tree0_Tree0Root = AppendRule(Tree0_Tree0Root, Dfa_TabCh, ScanGen_TabText);
  611.           Tree0_Tree0Root = AppendRule(Tree0_Tree0Root, Dfa_EolCh, ScanGen_EolText);
  612.           break;
  613.         case 119:;
  614.           DEC1(yyStackPtr, 0);
  615.           yyNonterminal = 46;
  616.           break;
  617.         case 120:;
  618.         case 88:;
  619.           DEC1(yyStackPtr, 2);
  620.           yyNonterminal = 46;
  621.           break;
  622.         case 121:;
  623.           DEC1(yyStackPtr, 0);
  624.           yyNonterminal = 48;
  625.           yySynAttribute.U_1.V_2.Tree = nNode;
  626.           break;
  627.         case 122:;
  628.         case 95:;
  629.           DEC1(yyStackPtr, 2);
  630.           yyNonterminal = 48;
  631.           yySynAttribute.U_1.V_2.Tree = Tree0_mList(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yyAttributeStack->A[yyStackPtr + 2].U_1.V_2.Tree);
  632.           break;
  633.         case 123:;
  634.         case 91:;
  635.           DEC1(yyStackPtr, 1);
  636.           yyNonterminal = 47;
  637.           break;
  638.         case 124:;
  639.         case 90:;
  640.           DEC1(yyStackPtr, 2);
  641.           yyNonterminal = 47;
  642.           break;
  643.         case 125:;
  644.         case 89:;
  645.           DEC1(yyStackPtr, 3);
  646.           yyNonterminal = 47;
  647.           break;
  648.         case 126:;
  649.         case 77:;
  650.           DEC1(yyStackPtr, 1);
  651.           yyNonterminal = 51;
  652.           Definition = DefTable_GetDef(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident);
  653.           if (Definition == DefTable_NoDef) {
  654.             DefTable_MakeStartDef(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident, (SHORTCARD)(GenTabs_StartStateCount + 1));
  655.             INC1(GenTabs_StartStateCount, 2);
  656.           } else {
  657.             Idents_GetString(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident, &string);
  658.             Errors_ErrorMessageI((LONGCARD)IdentDefBefore, (LONGCARD)Error, yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.Position, (LONGCARD)C_1_String, ADR(string));
  659.           }
  660.           break;
  661.         case 127:;
  662.         case 92:;
  663.           DEC1(yyStackPtr, 1);
  664.           yyNonterminal = 53;
  665.           Sets_MakeSet(&yySynAttribute.U_1.V_4.Set, (LONGCARD)GenTabs_StartStateCount);
  666.           Sets_Include(&yySynAttribute.U_1.V_4.Set, (LONGCARD)yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_2.Number);
  667.           Sets_Include(&yySynAttribute.U_1.V_4.Set, (LONGCARD)(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_2.Number + 1));
  668.           break;
  669.         case 128:;
  670.         case 94:;
  671.           DEC1(yyStackPtr, 2);
  672.           yyNonterminal = 53;
  673.           yySynAttribute.U_1.V_4.Set = yyAttributeStack->A[yyStackPtr + 1].U_1.V_4.Set;
  674.           Sets_Include(&yySynAttribute.U_1.V_4.Set, (LONGCARD)yyAttributeStack->A[yyStackPtr + 2].U_1.V_1.Scan.U_1.V_2.Number);
  675.           Sets_Include(&yySynAttribute.U_1.V_4.Set, (LONGCARD)(yyAttributeStack->A[yyStackPtr + 2].U_1.V_1.Scan.U_1.V_2.Number + 1));
  676.           break;
  677.         case 129:;
  678.         case 93:;
  679.           DEC1(yyStackPtr, 3);
  680.           yyNonterminal = 53;
  681.           yySynAttribute.U_1.V_4.Set = yyAttributeStack->A[yyStackPtr + 1].U_1.V_4.Set;
  682.           Sets_Include(&yySynAttribute.U_1.V_4.Set, (LONGCARD)yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_2.Number);
  683.           Sets_Include(&yySynAttribute.U_1.V_4.Set, (LONGCARD)(yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_2.Number + 1));
  684.           break;
  685.         case 130:;
  686.         case 78:;
  687.           DEC1(yyStackPtr, 1);
  688.           yyNonterminal = 52;
  689.           yySynAttribute.U_1.V_1.Scan.U_1.V_2.Number = 0;
  690.           Definition = DefTable_GetDef(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident);
  691.           if (Definition == DefTable_NoDef) {
  692.             Idents_GetString(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident, &string);
  693.             Errors_ErrorMessageI((LONGCARD)IdentUndefined, (LONGCARD)Error, yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.Position, (LONGCARD)C_1_String, ADR(string));
  694.           } else if (DefTable_GetKind(Definition) != DefTable_Start) {
  695.             Idents_GetString(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident, &string);
  696.             Errors_ErrorMessageI((LONGCARD)ImproperUse, (LONGCARD)Error, yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.Position, (LONGCARD)C_1_String, ADR(string));
  697.           } else {
  698.             DefTable_GetStartDef(Definition, &Identifier, &yySynAttribute.U_1.V_1.Scan.U_1.V_2.Number);
  699.           }
  700.           break;
  701.         case 131:;
  702.         case 72:;
  703.           DEC1(yyStackPtr, 4);
  704.           yyNonterminal = 49;
  705.           Definition = DefTable_GetDef(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident);
  706.           if (Definition == DefTable_NoDef) {
  707.             DefTable_MakeIdentDef(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident, (Tree_tTree)(ADDRESS)yyAttributeStack->A[yyStackPtr + 3].U_1.V_2.Tree, 0, FALSE);
  708.           } else {
  709.             Idents_GetString(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident, &string);
  710.             Errors_ErrorMessageI((LONGCARD)IdentDefBefore, (LONGCARD)Error, yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.Position, (LONGCARD)C_1_String, ADR(string));
  711.           }
  712.           break;
  713.         case 132:;
  714.         case 83:;
  715.           DEC1(yyStackPtr, 3);
  716.           yyNonterminal = 50;
  717.           INC(GenTabs_RuleCount);
  718.           yySynAttribute.U_1.V_2.Tree = Tree0_mRule(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text, yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line, ScanGen_Position, GenTabs_RuleCount);
  719.           break;
  720.         case 133:;
  721.         case 84:;
  722.           DEC1(yyStackPtr, 3);
  723.           yyNonterminal = 50;
  724.           INC(GenTabs_RuleCount);
  725.           yySynAttribute.U_1.V_2.Tree = Tree0_mRule(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_5.Text, yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.Position.Line, ScanGen_NoPosition, GenTabs_RuleCount);
  726.           break;
  727.         case 134:;
  728.         case 98:;
  729.           DEC1(yyStackPtr, 1);
  730.           yyNonterminal = 55;
  731.           yySynAttribute.U_1.V_2.Tree = Tree0_mList(nNode, yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree);
  732.           break;
  733.         case 135:;
  734.         case 96:;
  735.           DEC1(yyStackPtr, 3);
  736.           yyNonterminal = 55;
  737.           yySynAttribute.U_1.V_2.Tree = Tree0_mList(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yyAttributeStack->A[yyStackPtr + 3].U_1.V_2.Tree);
  738.           break;
  739.         case 136:;
  740.         case 97:;
  741.           DEC1(yyStackPtr, 5);
  742.           yyNonterminal = 56;
  743.           if (yyAttributeStack->A[yyStackPtr + 4].U_1.V_2.Tree == nNode) {
  744.             tree = yyAttributeStack->A[yyStackPtr + 5].U_1.V_2.Tree;
  745.           } else {
  746.             if (yyAttributeStack->A[yyStackPtr + 5].U_1.V_2.Tree == nNode) {
  747.               tree = yyAttributeStack->A[yyStackPtr + 4].U_1.V_2.Tree;
  748.             } else {
  749.               tree = Tree0_mSequence(yyAttributeStack->A[yyStackPtr + 4].U_1.V_2.Tree, yyAttributeStack->A[yyStackPtr + 5].U_1.V_2.Tree);
  750.             }
  751.           }
  752.           if (yyAttributeStack->A[yyStackPtr + 2].U_1.V_3.IsLeftJust) {
  753.             {
  754.               SHORTCARD B_3 = 1, B_4 = (SHORTCARD)GenTabs_StartStateCount;
  755.  
  756.               if (B_3 <= B_4)
  757.                 for (Number = B_3, B_4 = FOR_LIMIT_UP(B_4, 2, MIN_SHORTCARD);; Number += 2) {
  758.                   Sets_Exclude(&yyAttributeStack->A[yyStackPtr + 1].U_1.V_4.Set, (LONGCARD)Number);
  759.                   if (Number >= B_4) break;
  760.                 }
  761.             }
  762.           }
  763.           INC(GenTabs_PatternCount);
  764.           yySynAttribute.U_1.V_2.Tree = Tree0_mPattern(yyAttributeStack->A[yyStackPtr + 1].U_1.V_4.Set, yyAttributeStack->A[yyStackPtr + 3].U_1.V_2.Tree, tree, GenTabs_PatternCount, yyAttributeStack->A[yyStackPtr + 2].U_1.V_3.Position);
  765.           break;
  766.         case 137:;
  767.           DEC1(yyStackPtr, 0);
  768.           yyNonterminal = 57;
  769.           Sets_MakeSet(&yySynAttribute.U_1.V_4.Set, (LONGCARD)GenTabs_StartStateCount);
  770.           Sets_Complement(&yySynAttribute.U_1.V_4.Set);
  771.           Sets_Exclude(&yySynAttribute.U_1.V_4.Set, 0L);
  772.           break;
  773.         case 138:;
  774.         case 80:;
  775.           DEC1(yyStackPtr, 3);
  776.           yyNonterminal = 57;
  777.           yySynAttribute.U_1.V_4.Set = yyAttributeStack->A[yyStackPtr + 2].U_1.V_4.Set;
  778.           break;
  779.         case 139:;
  780.         case 79:;
  781.           DEC1(yyStackPtr, 4);
  782.           yyNonterminal = 57;
  783.           yySynAttribute.U_1.V_4.Set = yyAttributeStack->A[yyStackPtr + 3].U_1.V_4.Set;
  784.           Sets_Complement(&yySynAttribute.U_1.V_4.Set);
  785.           Sets_Exclude(&yySynAttribute.U_1.V_4.Set, 0L);
  786.           break;
  787.         case 140:;
  788.           DEC1(yyStackPtr, 0);
  789.           yyNonterminal = 58;
  790.           yySynAttribute.U_1.V_3.IsLeftJust = FALSE;
  791.           yySynAttribute.U_1.V_3.Position = Scanner_Attribute.Position;
  792.           break;
  793.         case 141:;
  794.         case 81:;
  795.           DEC1(yyStackPtr, 1);
  796.           yyNonterminal = 58;
  797.           yySynAttribute.U_1.V_3.IsLeftJust = TRUE;
  798.           GenTabs_LeftJustUsed = TRUE;
  799.           yySynAttribute.U_1.V_3.Position = Scanner_Attribute.Position;
  800.           break;
  801.         case 142:;
  802.           DEC1(yyStackPtr, 0);
  803.           yyNonterminal = 59;
  804.           yySynAttribute.U_1.V_2.Tree = nNode;
  805.           break;
  806.         case 143:;
  807.           DEC1(yyStackPtr, 2);
  808.           yyNonterminal = 59;
  809.           yySynAttribute.U_1.V_2.Tree = yyAttributeStack->A[yyStackPtr + 2].U_1.V_2.Tree;
  810.           break;
  811.         case 144:;
  812.           DEC1(yyStackPtr, 0);
  813.           yyNonterminal = 60;
  814.           yySynAttribute.U_1.V_2.Tree = nNode;
  815.           break;
  816.         case 145:;
  817.         case 82:;
  818.           DEC1(yyStackPtr, 1);
  819.           yyNonterminal = 60;
  820.           yySynAttribute.U_1.V_2.Tree = EOLTree;
  821.           break;
  822.         case 146:;
  823.           DEC1(yyStackPtr, 3);
  824.           yyNonterminal = 54;
  825.           yySynAttribute.U_1.V_2.Tree = Tree0_mAlternative(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yyAttributeStack->A[yyStackPtr + 3].U_1.V_2.Tree);
  826.           break;
  827.         case 147:;
  828.           DEC1(yyStackPtr, 2);
  829.           yyNonterminal = 54;
  830.           yySynAttribute.U_1.V_2.Tree = Tree0_mSequence(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yyAttributeStack->A[yyStackPtr + 2].U_1.V_2.Tree);
  831.           break;
  832.         case 148:;
  833.         case 66:;
  834.           DEC1(yyStackPtr, 2);
  835.           yyNonterminal = 54;
  836.           yySynAttribute.U_1.V_2.Tree = Tree0_mRepetition(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree);
  837.           break;
  838.         case 149:;
  839.         case 67:;
  840.           DEC1(yyStackPtr, 2);
  841.           yyNonterminal = 54;
  842.           yySynAttribute.U_1.V_2.Tree = Tree0_mOption(Tree0_mRepetition(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree));
  843.           break;
  844.         case 150:;
  845.         case 68:;
  846.           DEC1(yyStackPtr, 2);
  847.           yyNonterminal = 54;
  848.           yySynAttribute.U_1.V_2.Tree = Tree0_mOption(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree);
  849.           break;
  850.         case 151:;
  851.         case 70:;
  852.           DEC1(yyStackPtr, 4);
  853.           yyNonterminal = 54;
  854.           yySynAttribute.U_1.V_2.Tree = nNode;
  855.           {
  856.             SHORTCARD B_5 = 1, B_6 = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_2.Number;
  857.  
  858.             if (B_5 <= B_6)
  859.               for (Number = B_5;; Number += 1) {
  860.                 yySynAttribute.U_1.V_2.Tree = Tree0_mSequence(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yySynAttribute.U_1.V_2.Tree);
  861.                 if (Number >= B_6) break;
  862.               }
  863.           }
  864.           break;
  865.         case 152:;
  866.         case 69:;
  867.           DEC1(yyStackPtr, 6);
  868.           yyNonterminal = 54;
  869.           yySynAttribute.U_1.V_2.Tree = nNode;
  870.           tree = Tree0_mOption(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree);
  871.           {
  872.             SHORTCARD B_7 = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_2.Number + 1, B_8 = yyAttributeStack->A[yyStackPtr + 5].U_1.V_1.Scan.U_1.V_2.Number;
  873.  
  874.             if (B_7 <= B_8)
  875.               for (Number = B_7;; Number += 1) {
  876.                 yySynAttribute.U_1.V_2.Tree = Tree0_mSequence(tree, yySynAttribute.U_1.V_2.Tree);
  877.                 if (Number >= B_8) break;
  878.               }
  879.           }
  880.           {
  881.             SHORTCARD B_9 = 1, B_10 = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_2.Number;
  882.  
  883.             if (B_9 <= B_10)
  884.               for (Number = B_9;; Number += 1) {
  885.                 yySynAttribute.U_1.V_2.Tree = Tree0_mSequence(yyAttributeStack->A[yyStackPtr + 1].U_1.V_2.Tree, yySynAttribute.U_1.V_2.Tree);
  886.                 if (Number >= B_10) break;
  887.               }
  888.           }
  889.           break;
  890.         case 153:;
  891.         case 71:;
  892.           DEC1(yyStackPtr, 3);
  893.           yyNonterminal = 54;
  894.           yySynAttribute.U_1.V_2.Tree = yyAttributeStack->A[yyStackPtr + 2].U_1.V_2.Tree;
  895.           break;
  896.         case 154:;
  897.         case 87:;
  898.           DEC1(yyStackPtr, 1);
  899.           yyNonterminal = 54;
  900.           yySynAttribute.U_1.V_2.Tree = Tree0_mSet(yyAttributeStack->A[yyStackPtr + 1].U_1.V_4.Set);
  901.           break;
  902.         case 155:;
  903.         case 63:;
  904.           DEC1(yyStackPtr, 1);
  905.           yyNonterminal = 54;
  906.           yySynAttribute.U_1.V_2.Tree = Tree0_mCh(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_4.Ch);
  907.           break;
  908.         case 156:;
  909.         case 60:;
  910.           DEC1(yyStackPtr, 1);
  911.           yyNonterminal = 54;
  912.           Definition = DefTable_GetDef(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident);
  913.           if (Definition != DefTable_NoDef) {
  914.             if (DefTable_GetKind(Definition) == DefTable_Ident) {
  915.               DefTable_GetIdentDef(Definition, &Identifier, &tree1, &Number, &bool);
  916.               yySynAttribute.U_1.V_2.Tree = (Tree0_tTree0)(ADDRESS)tree1;
  917.             } else {
  918.               Idents_GetString(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident, &string);
  919.               Errors_ErrorMessageI((LONGCARD)ImproperUse, (LONGCARD)Error, yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.Position, (LONGCARD)C_1_String, ADR(string));
  920.               yySynAttribute.U_1.V_2.Tree = nNode;
  921.             }
  922.           } else {
  923.             stringref = Idents_GetStringRef(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_1.Ident);
  924.             yySynAttribute.U_1.V_2.Tree = Tree0_mString(stringref);
  925.           }
  926.           break;
  927.         case 157:;
  928.         case 62:;
  929.           DEC1(yyStackPtr, 1);
  930.           yyNonterminal = 54;
  931.           yySynAttribute.U_1.V_2.Tree = Tree0_mString(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_3.String);
  932.           break;
  933.         case 158:;
  934.         case 61:;
  935.           DEC1(yyStackPtr, 1);
  936.           yyNonterminal = 54;
  937.           Strings_IntToString((LONGINT)yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_2.Number, &string);
  938.           yySynAttribute.U_1.V_2.Tree = Tree0_mString(StringMem_PutString(&string));
  939.           break;
  940.         case 159:;
  941.         case 86:;
  942.           DEC1(yyStackPtr, 2);
  943.           yyNonterminal = 61;
  944.           yySynAttribute.U_1.V_4.Set = yyAttributeStack->A[yyStackPtr + 2].U_1.V_4.Set;
  945.           Sets_Complement(&yySynAttribute.U_1.V_4.Set);
  946.           break;
  947.         case 160:;
  948.         case 65:;
  949.           DEC1(yyStackPtr, 3);
  950.           yyNonterminal = 61;
  951.           yySynAttribute.U_1.V_4.Set = yyAttributeStack->A[yyStackPtr + 2].U_1.V_4.Set;
  952.           break;
  953.         case 161:;
  954.           DEC1(yyStackPtr, 0);
  955.           yyNonterminal = 62;
  956.           Sets_MakeSet(&yySynAttribute.U_1.V_4.Set, ORD(Dfa_LastCh));
  957.           break;
  958.         case 162:;
  959.         case 85:;
  960.           DEC1(yyStackPtr, 2);
  961.           yyNonterminal = 62;
  962.           yySynAttribute.U_1.V_4.Set = yyAttributeStack->A[yyStackPtr + 1].U_1.V_4.Set;
  963.           Sets_Union(&yySynAttribute.U_1.V_4.Set, yyAttributeStack->A[yyStackPtr + 2].U_1.V_4.Set);
  964.           Sets_ReleaseSet(&yyAttributeStack->A[yyStackPtr + 2].U_1.V_4.Set);
  965.           break;
  966.         case 163:;
  967.           DEC1(yyStackPtr, 1);
  968.           yyNonterminal = 63;
  969.           Sets_MakeSet(&yySynAttribute.U_1.V_4.Set, ORD(Dfa_LastCh));
  970.           Sets_Include(&yySynAttribute.U_1.V_4.Set, ORD(yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_4.Ch));
  971.           break;
  972.         case 164:;
  973.         case 64:;
  974.           DEC1(yyStackPtr, 3);
  975.           yyNonterminal = 63;
  976.           Sets_MakeSet(&yySynAttribute.U_1.V_4.Set, ORD(Dfa_LastCh));
  977.           {
  978.             CHAR B_11 = yyAttributeStack->A[yyStackPtr + 1].U_1.V_1.Scan.U_1.V_4.Ch, B_12 = yyAttributeStack->A[yyStackPtr + 3].U_1.V_1.Scan.U_1.V_4.Ch;
  979.  
  980.             if (B_11 <= B_12)
  981.               for (ch = B_11;; ch += 1) {
  982.                 Sets_Include(&yySynAttribute.U_1.V_4.Set, ORD(ch));
  983.                 if (ch >= B_12) break;
  984.               }
  985.           }
  986.           break;
  987.         }
  988.         yyNCombPtr = (yyNCombTypePtr)((LONGCARD)yyNBasePtr.A[yyStateStack->A[yyStackPtr]] + yyNonterminal * sizeof(yyNCombType));
  989.         yyState = *yyNCombPtr;
  990.         INC(yyStackPtr);
  991.         yyAttributeStack->A[yyStackPtr] = yySynAttribute;
  992.         if (yyState < yyFirstFinalState) {
  993.           goto EXIT_3;
  994.         }
  995.       } EXIT_3:;
  996.     } else {
  997.       INC(yyStackPtr);
  998.       yyAttributeStack->A[yyStackPtr].U_1.V_1.Scan = Scanner_Attribute;
  999.       yyTerminal = Scanner_GetToken();
  1000.       yyIsRepairing = FALSE;
  1001.     }
  1002.   } EXIT_1:;
  1003. }
  1004.  
  1005. static void ErrorRecovery
  1006. # ifdef __STDC__
  1007. (yySymbolRange *Terminal, yyStackType StateStack, LONGINT StackSize, LONGINT StackPtr)
  1008. # else
  1009. (Terminal, StateStack, StackSize, StackPtr)
  1010. yySymbolRange *Terminal;
  1011. yyStackType StateStack;
  1012. LONGINT StackSize;
  1013. LONGINT StackPtr;
  1014. # endif
  1015. {
  1016.   BOOLEAN TokensSkipped;
  1017.   Sets_tSet ContinueSet;
  1018.   Sets_tSet RestartSet;
  1019.   yySymbolRange Token;
  1020.   struct S_18 TokenArray;
  1021.   Strings_tString TokenString;
  1022.   Strings_tString ContinueString;
  1023.  
  1024.   Errors_ErrorMessage((LONGCARD)Errors_SyntaxError, (LONGCARD)Errors_Error, Scanner_Attribute.Position);
  1025.   Sets_MakeSet(&ContinueSet, (LONGCARD)yyLastTerminal);
  1026.   ComputeContinuation(StateStack, StackSize, StackPtr, &ContinueSet);
  1027.   Strings_AssignEmpty(&ContinueString);
  1028.   {
  1029.     yySymbolRange B_13 = Sets_Minimum(&ContinueSet), B_14 = Sets_Maximum(&ContinueSet);
  1030.  
  1031.     if (B_13 <= B_14)
  1032.       for (Token = B_13;; Token += 1) {
  1033.         if (Sets_IsElement((LONGCARD)Token, &ContinueSet)) {
  1034.           Parser_TokenName((LONGCARD)Token, TokenArray.A, 128L);
  1035.           Strings_ArrayToString(TokenArray.A, 128L, &TokenString);
  1036.           if (Strings_Length(&ContinueString) + Strings_Length(&TokenString) + 1 <= Strings_cMaxStrLength) {
  1037.             Strings_Concatenate(&ContinueString, &TokenString);
  1038.             Strings_Append(&ContinueString, ' ');
  1039.           }
  1040.         }
  1041.         if (Token >= B_14) break;
  1042.       }
  1043.   }
  1044.   Errors_ErrorMessageI((LONGCARD)Errors_ExpectedTokens, (LONGCARD)Errors_Information, Scanner_Attribute.Position, (LONGCARD)Errors_String, ADR(ContinueString));
  1045.   Sets_ReleaseSet(&ContinueSet);
  1046.   Sets_MakeSet(&RestartSet, (LONGCARD)yyLastTerminal);
  1047.   ComputeRestartPoints(StateStack, StackSize, StackPtr, &RestartSet);
  1048.   TokensSkipped = FALSE;
  1049.   while (!Sets_IsElement((LONGCARD)(*Terminal), &RestartSet)) {
  1050.     *Terminal = Scanner_GetToken();
  1051.     TokensSkipped = TRUE;
  1052.   }
  1053.   Sets_ReleaseSet(&RestartSet);
  1054.   if (TokensSkipped) {
  1055.     Errors_ErrorMessage((LONGCARD)Errors_RestartPoint, (LONGCARD)Errors_Information, Scanner_Attribute.Position);
  1056.   }
  1057. }
  1058.  
  1059. static void ComputeContinuation
  1060. # ifdef __STDC__
  1061. (yyStackType Stack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *ContinueSet)
  1062. # else
  1063. (Stack, StackSize, StackPtr, ContinueSet)
  1064. yyStackType Stack;
  1065. LONGINT StackSize;
  1066. LONGINT StackPtr;
  1067. Sets_tSet *ContinueSet;
  1068. # endif
  1069. {
  1070.   yySymbolRange Terminal;
  1071.  
  1072.   Sets_AssignEmpty(ContinueSet);
  1073.   for (Terminal = yyFirstTerminal; Terminal <= yyLastTerminal; Terminal += 1) {
  1074.     if (IsContinuation(Terminal, Stack, StackSize, StackPtr)) {
  1075.       Sets_Include(ContinueSet, (LONGCARD)Terminal);
  1076.     }
  1077.   }
  1078. }
  1079.  
  1080. static BOOLEAN IsContinuation
  1081. # ifdef __STDC__
  1082. (yySymbolRange Terminal, yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr)
  1083. # else
  1084. (Terminal, ParseStack, StackSize, StackPtr)
  1085. yySymbolRange Terminal;
  1086. yyStackType ParseStack;
  1087. LONGINT StackSize;
  1088. LONGINT StackPtr;
  1089. # endif
  1090. {
  1091.   LONGINT State;
  1092.   yySymbolRange Nonterminal;
  1093.   yyStackType Stack;
  1094.  
  1095.   DynArray_MakeArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1096.   {
  1097.     LONGINT B_15 = 0, B_16 = StackPtr;
  1098.  
  1099.     if (B_15 <= B_16)
  1100.       for (State = B_15;; State += 1) {
  1101.         Stack->A[State] = ParseStack->A[State];
  1102.         if (State >= B_16) break;
  1103.       }
  1104.   }
  1105.   State = Stack->A[StackPtr];
  1106.   for (;;) {
  1107.     Stack->A[StackPtr] = State;
  1108.     State = Next((yyStateRange)State, Terminal);
  1109.     if (State == yyNoState) {
  1110.       DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1111.       return FALSE;
  1112.     }
  1113.     if (State <= yyLastReadTermState) {
  1114.       DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1115.       return TRUE;
  1116.     }
  1117.     for (;;) {
  1118.       if (State == yyStopState) {
  1119.         DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1120.         return TRUE;
  1121.       } else {
  1122.         DEC1(StackPtr, yyLength.A[State - 100]);
  1123.         Nonterminal = yyLeftHandSide.A[State - 100];
  1124.       }
  1125.       State = Next(Stack->A[StackPtr], Nonterminal);
  1126.       if (StackPtr >= StackSize) {
  1127.         DynArray_ExtendArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1128.       }
  1129.       INC(StackPtr);
  1130.       if (State < yyFirstFinalState) {
  1131.         goto EXIT_5;
  1132.       }
  1133.       State = yyFinalToProd.A[State - 56];
  1134.     } EXIT_5:;
  1135.   } EXIT_4:;
  1136. }
  1137.  
  1138. static void ComputeRestartPoints
  1139. # ifdef __STDC__
  1140. (yyStackType ParseStack, LONGINT StackSize, LONGINT StackPtr, Sets_tSet *RestartSet)
  1141. # else
  1142. (ParseStack, StackSize, StackPtr, RestartSet)
  1143. yyStackType ParseStack;
  1144. LONGINT StackSize;
  1145. LONGINT StackPtr;
  1146. Sets_tSet *RestartSet;
  1147. # endif
  1148. {
  1149.   yyStackType Stack;
  1150.   LONGINT State;
  1151.   yySymbolRange Nonterminal;
  1152.   Sets_tSet ContinueSet;
  1153.  
  1154.   DynArray_MakeArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1155.   {
  1156.     LONGINT B_17 = 0, B_18 = StackPtr;
  1157.  
  1158.     if (B_17 <= B_18)
  1159.       for (State = B_17;; State += 1) {
  1160.         Stack->A[State] = ParseStack->A[State];
  1161.         if (State >= B_18) break;
  1162.       }
  1163.   }
  1164.   Sets_MakeSet(&ContinueSet, (LONGCARD)yyLastTerminal);
  1165.   Sets_AssignEmpty(RestartSet);
  1166.   State = Stack->A[StackPtr];
  1167.   for (;;) {
  1168.     if (StackPtr >= StackSize) {
  1169.       DynArray_ExtendArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1170.     }
  1171.     Stack->A[StackPtr] = State;
  1172.     ComputeContinuation(Stack, StackSize, StackPtr, &ContinueSet);
  1173.     Sets_Union(RestartSet, ContinueSet);
  1174.     State = Next((yyStateRange)State, yyContinuation.A[State]);
  1175.     if (State >= yyFirstFinalState) {
  1176.       if (State <= yyLastReadTermState) {
  1177.         INC(StackPtr);
  1178.         State = yyFinalToProd.A[State - 56];
  1179.       }
  1180.       for (;;) {
  1181.         if (State == yyStopState) {
  1182.           DynArray_ReleaseArray((ADDRESS *)&Stack, &StackSize, (LONGINT)sizeof(yyStateRange));
  1183.           Sets_ReleaseSet(&ContinueSet);
  1184.           return;
  1185.         } else {
  1186.           DEC1(StackPtr, yyLength.A[State - 100]);
  1187.           Nonterminal = yyLeftHandSide.A[State - 100];
  1188.         }
  1189.         State = Next(Stack->A[StackPtr], Nonterminal);
  1190.         INC(StackPtr);
  1191.         if (State < yyFirstFinalState) {
  1192.           goto EXIT_7;
  1193.         }
  1194.         State = yyFinalToProd.A[State - 56];
  1195.       } EXIT_7:;
  1196.     } else {
  1197.       INC(StackPtr);
  1198.     }
  1199.   } EXIT_6:;
  1200. }
  1201.  
  1202. static yyStateRange Next
  1203. # ifdef __STDC__
  1204. (yyStateRange State, yySymbolRange Symbol)
  1205. # else
  1206. (State, Symbol)
  1207. yyStateRange State;
  1208. yySymbolRange Symbol;
  1209. # endif
  1210. {
  1211.   yyTCombTypePtr TCombPtr;
  1212.   yyNCombTypePtr NCombPtr;
  1213.  
  1214.   if (Symbol <= yyLastTerminal) {
  1215.     for (;;) {
  1216.       TCombPtr = (yyTCombTypePtr)((LONGCARD)yyTBasePtr.A[State] + Symbol * sizeof(yyTCombType));
  1217.       if (TCombPtr->Check != State) {
  1218.         State = yyDefault.A[State];
  1219.         if (State == yyNoState) {
  1220.           return yyNoState;
  1221.         }
  1222.       } else {
  1223.         return TCombPtr->Next;
  1224.       }
  1225.     } EXIT_8:;
  1226.   } else {
  1227.     NCombPtr = (yyNCombTypePtr)((LONGCARD)yyNBasePtr.A[State] + Symbol * sizeof(yyNCombType));
  1228.     return *NCombPtr;
  1229.   }
  1230. }
  1231.  
  1232. static void yyGetTables
  1233. # ifdef __STDC__
  1234. ()
  1235. # else
  1236. ()
  1237. # endif
  1238. {
  1239.   CARDINAL BlockSize, j, n;
  1240.   yyStateRange State;
  1241.   struct S_19 TBase;
  1242.   struct S_20 NBase;
  1243.  
  1244.   BlockSize = 64000 / sizeof(yyTCombType);
  1245.   yyTableFile = OpenInput(Parser_ParsTabName.A, 129L);
  1246.   yyErrorCheck((LONGINT)Errors_OpenParseTable, yyTableFile);
  1247.   if (yyGetTable(ADR(TBase)) / sizeof(yyTCombRange) - 1 != yyLastReadState || yyGetTable(ADR(NBase)) / sizeof(yyNCombRange) - 1 != yyLastReadState || yyGetTable(ADR(yyDefault)) / sizeof(yyReadRange) - 1 != yyLastReadState || yyGetTable(ADR(yyNComb)) / sizeof(yyNCombType) != yyNTableMax - yyLastTerminal || yyGetTable(ADR(yyLength)) / sizeof(yyTableElmt) - 1 != yyLastReduceState - yyFirstReduceState || yyGetTable(ADR(yyLeftHandSide)) / sizeof(yySymbolRange) - 1 != yyLastReduceState - yyFirstReduceState || yyGetTable(ADR(yyContinuation)) / sizeof(yySymbolRange) - 1 != yyLastReadState || yyGetTable(ADR(yyFinalToProd)) / sizeof(yyReduceRange) - 1 != yyLastReadNontermState - yyFirstReadTermState) {
  1248.     Errors_ErrorMessage((LONGCARD)Errors_WrongParseTable, (LONGCARD)Errors_Fatal, Positions_NoPosition);
  1249.   }
  1250.   n = 0;
  1251.   j = 0;
  1252.   while (j <= yyTableMax) {
  1253.     INC1(n, yyGetTable(ADR(yyTComb.A[j])) / sizeof(yyTCombType));
  1254.     INC1(j, BlockSize);
  1255.   }
  1256.   if (n != yyTableMax + 1) {
  1257.     Errors_ErrorMessage((LONGCARD)Errors_WrongParseTable, (LONGCARD)Errors_Fatal, Positions_NoPosition);
  1258.   }
  1259.   Close(yyTableFile);
  1260.   for (State = 1; State <= yyLastReadState; State += 1) {
  1261.     yyTBasePtr.A[State] = (yyTCombTypePtr)ADR(yyTComb.A[TBase.A[State]]);
  1262.   }
  1263.   for (State = 1; State <= yyLastReadState; State += 1) {
  1264.     yyNBasePtr.A[State] = (yyNCombTypePtr)ADR(yyNComb.A[NBase.A[State] - 39]);
  1265.   }
  1266. }
  1267.  
  1268. static CARDINAL yyGetTable
  1269. # ifdef __STDC__
  1270. (ADDRESS Address)
  1271. # else
  1272. (Address)
  1273. ADDRESS Address;
  1274. # endif
  1275. {
  1276.   INTEGER N;
  1277.   yyTableElmt Length;
  1278.  
  1279.   N = Read(yyTableFile, ADR(Length), (LONGCARD)sizeof(yyTableElmt));
  1280.   yyErrorCheck((LONGINT)Errors_ReadParseTable, N);
  1281.   N = Read(yyTableFile, Address, (LONGCARD)Length);
  1282.   yyErrorCheck((LONGINT)Errors_ReadParseTable, N);
  1283.   return Length;
  1284. }
  1285.  
  1286. static void yyErrorCheck
  1287. # ifdef __STDC__
  1288. (INTEGER ErrorCode, INTEGER Info)
  1289. # else
  1290. (ErrorCode, Info)
  1291. INTEGER ErrorCode;
  1292. INTEGER Info;
  1293. # endif
  1294. {
  1295.   INTEGER ErrNo;
  1296.  
  1297.   if (Info < 0) {
  1298.     ErrNo = ErrNum();
  1299.     Errors_ErrorMessageI((LONGCARD)ErrorCode, (LONGCARD)Errors_Fatal, Positions_NoPosition, (LONGCARD)Errors_Integer, ADR(ErrNo));
  1300.   }
  1301. }
  1302.  
  1303. static void BeginParser
  1304. # ifdef __STDC__
  1305. ()
  1306. # else
  1307. ()
  1308. # endif
  1309. {
  1310.   nNode = Tree0_mNode();
  1311.   if (!yyIsInitialized) {
  1312.     yyIsInitialized = TRUE;
  1313.     yyGetTables();
  1314.   }
  1315. }
  1316.  
  1317. void Parser_CloseParser
  1318. # ifdef __STDC__
  1319. ()
  1320. # else
  1321. ()
  1322. # endif
  1323. {
  1324. }
  1325.  
  1326. void BEGIN_Parser()
  1327. {
  1328.   static BOOLEAN has_been_called = FALSE;
  1329.  
  1330.   if (!has_been_called) {
  1331.     has_been_called = TRUE;
  1332.  
  1333.     BEGIN_Scanner();
  1334.     BEGIN_Positions();
  1335.     BEGIN_Errors();
  1336.     BEGIN_Strings();
  1337.     BEGIN_DynArray();
  1338.     BEGIN_Sets();
  1339.     BEGIN_System();
  1340.     BEGIN_Errors();
  1341.     BEGIN_Tree0();
  1342.     BEGIN_Tree();
  1343.     BEGIN_Sets();
  1344.     BEGIN_Strings();
  1345.     BEGIN_Lists();
  1346.     BEGIN_StringMem();
  1347.     BEGIN_Idents();
  1348.     BEGIN_DefTable();
  1349.     BEGIN_GenTabs();
  1350.     BEGIN_Dfa();
  1351.     BEGIN_ScanGen();
  1352.  
  1353.     yyIsInitialized = FALSE;
  1354.     (void)strncpy((char *)Parser_ParsTabName.A, "Parser.Tab", sizeof(Parser_ParsTabName.A));
  1355.   }
  1356. }
  1357.